﻿using System;
using System.Collections.Generic;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
using System.Web.Security;
using Event_Planner.Models;

namespace Event_Planner.Controllers
{

    public class AccountController : Controller
    {
        public Event_Planner.DataAccess.Usuarios DataAccessUsuarios = new Event_Planner.DataAccess.Usuarios();


        public ActionResult Index()
        {
            if (User.IsInRole("Administrador"))
            {
                return View(Membership.GetAllUsers());
            }
            else return RedirectToAction("Details", new {Nombre = User.Identity.Name });
        }



        //
        // GET: /Account/Details/Nombre
        public ActionResult Details(string Nombre)
        {
            MembershipUser Persona = Membership.FindUsersByName(Nombre)[Nombre];

            if (Persona == null)
                return RedirectToAction("ErrorPersonalizado", "Error", new { MensajeError = "el usuario ya no existe." });
            else
                return View(Persona);
        }


        //
        // GET: /Account/Edit/Nombre
        public ActionResult Edit(string Nombre)
        {

            MembershipUser Persona = Membership.FindUsersByName(Nombre)[Nombre];

            if (Persona == null)
                return RedirectToAction("ErrorPersonalizado", "Error", new { MensajeError = "el usuario ya no existe." });
            else
            {
                // Armo un modelo valido para poder usarlo en la vista.

                UsuariosModel usuariosmodel = new UsuariosModel()
                {
                    NombreUsuario = Persona.UserName,
                    EmailUsuario = Persona.Email
                };

                return View(usuariosmodel);
            }
        }

        //
        // POST: /Account/Edit/Nombre

        [HttpPost]
        public ActionResult Edit(UsuariosModel usuariosmodel)
        {
            if (ModelState.IsValid)
            {

                string Nombre = usuariosmodel.NombreUsuario;
                MembershipUser Persona = Membership.FindUsersByName(Nombre)[Nombre];

                if (Persona == null)
                    return RedirectToAction("ErrorPersonalizado", "Error", new { MensajeError = "el usuario ya no existe." });
                else
                {
                    Persona.Email = usuariosmodel.EmailUsuario;

                    Membership.UpdateUser(Persona);

                    DataAccessUsuarios.db.Usuarios.Find(Nombre).EmailUsuario = usuariosmodel.EmailUsuario;
                    DataAccessUsuarios.db.SaveChanges();

                    return RedirectToAction("Index");
                }
            }
            return View(usuariosmodel);
        }



        //
        // GET: /Account/LogOn
        
        [AllowAnonymous]
        public ActionResult LogOn()
        {
            return View();
        }

        //
        // POST: /Account/LogOn

        [HttpPost]
        [AllowAnonymous]
        public ActionResult LogOn(LogOnModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                if (Membership.ValidateUser(model.UserName, model.Password))
                {
                    
                    FormsAuthentication.SetAuthCookie(model.UserName, model.RememberMe);
                    if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/")
                        && !returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
                            return Redirect(returnUrl);
                    else
                        return RedirectToAction("Index", "Home");
                }
                else
                    ModelState.AddModelError("", "El nombre de usuario o contraseña proporcionada es incorrecta.");
                
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

        //
        // GET: /Account/LogOff

        public ActionResult LogOff()
        {
            FormsAuthentication.SignOut();
            return RedirectToAction("Index", "Home");
        }

        //
        // GET: /Account/Register

        [AllowAnonymous]
        public ActionResult Register()
        {
            return View();
        }

        //
        // POST: /Account/Register

        [HttpPost]
        [AllowAnonymous]
        public ActionResult Register(RegisterModel model)
        {
            if (ModelState.IsValid)
            {
                // Attempt to register the user
                MembershipCreateStatus createStatus;
                Membership.CreateUser(model.UserName, model.Password, model.Email, "question", "answer", true, null, out createStatus);

                UsuariosModel usuariomodel = new UsuariosModel()
                {
                    NombreUsuario = model.UserName,
                    EmailUsuario = model.Email,
                };

                if (createStatus == MembershipCreateStatus.Success)
                {
                    FormsAuthentication.SetAuthCookie(model.UserName, false /* createPersistentCookie */);

                    DataAccessUsuarios.db.Usuarios.Add(usuariomodel);
                    DataAccessUsuarios.db.SaveChanges();

                    return RedirectToAction("Index", "Home");
                }
                else
                {
                    ModelState.AddModelError("", ErrorCodeToString(createStatus));
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }




        //
        // GET: /Default1/Delete/Nombre
        public ActionResult Delete(string Nombre)
        {

            MembershipUser Persona = Membership.FindUsersByName(Nombre)[Nombre];

            if (Persona == null)
                return RedirectToAction("ErrorPersonalizado", "Error", new { MensajeError = "el usuario ya no existe." });
            else
            {

                // Armo un modelo valido para poder usarlo en la vista.

                UsuariosModel usuariosmodel = new UsuariosModel()
                {
                    NombreUsuario = Persona.UserName,
                    EmailUsuario = Persona.Email,
                };

                return View(usuariosmodel);
            }
        }

        

        //
        // POST: /Default1/Delete/Nombre

        [HttpPost, ActionName("Delete")]
        public ActionResult DeleteConfirmed(string Nombre)
        {
            MembershipUser Persona = Membership.FindUsersByName(Nombre)[Nombre];

            if (Persona == null)
                return RedirectToAction("ErrorPersonalizado", "Error", new { MensajeError = "el usuario ya no existe." });
            else
                if (Persona.UserName == "Administrador")
                    return RedirectToAction("ErrorPersonalizado", "Error", new { MensajeError = "el administrador no puede ser borrado." });
                else
                {
                    DataAccessUsuarios.EliminarUsuarioCompletamente(Nombre);

                    Membership.DeleteUser(Persona.UserName, true);

                    Event_Planner.Filters.Cache.ResetOutputCache();

                    if (User.IsInRole("Administrador"))
                        return RedirectToAction("Index");
                    else
                        return RedirectToAction("LogOff");
                }
            
        }


        //
        // GET: /Account/ChangePassword

        public ActionResult ChangePassword()
        {
            return View();
        }

        //
        // POST: /Account/ChangePassword

       
        [HttpPost]
        public ActionResult ChangePassword(ChangePasswordModel model)
        {
            if (ModelState.IsValid)
            {

                // ChangePassword will throw an exception rather
                // than return false in certain failure scenarios.
                bool changePasswordSucceeded;
                try
                {
                    MembershipUser currentUser = Membership.GetUser(User.Identity.Name, true /* userIsOnline */);
                    changePasswordSucceeded = currentUser.ChangePassword(model.OldPassword, model.NewPassword);
                }
                catch (Exception)
                {
                    changePasswordSucceeded = false;
                }

                if (changePasswordSucceeded)
                {
                    return RedirectToAction("ChangePasswordSuccess");
                }
                else
                {
                    ModelState.AddModelError("", "La contraseña actual es incorrecta o la nueva contraseña no es válida.");
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

        //
        // GET: /Account/ChangePasswordSuccess

        public ActionResult ChangePasswordSuccess()
        {
            return View();
        }


        #region Status Codes
        private static string ErrorCodeToString(MembershipCreateStatus createStatus)
        {
            // See http://go.microsoft.com/fwlink/?LinkID=177550 for
            // a full list of status codes.
            switch (createStatus)
            {
                case MembershipCreateStatus.DuplicateUserName:
                    return "El nombre de usuario ya existe. Por favor, introduzca un nombre de usuario diferente.";

                case MembershipCreateStatus.DuplicateEmail:
                    return "Un nombre de usuario para esa dirección de correo electrónico ya existe. Por favor, introduzca otra dirección de correo electrónico.";

                case MembershipCreateStatus.InvalidPassword:
                    return "La contraseña proporcionada no es válida. Por favor, introduzca una contraseña válida. Recuerde que la longitud mínima de la contraseña: 7 y se requieren caracteres no alfanuméricos: 1.";

                case MembershipCreateStatus.InvalidEmail:
                    return "La dirección de correo electrónico proporcionada no es válida. Por favor, compruebe el valor y vuelva a intentarlo.";

                case MembershipCreateStatus.InvalidAnswer:
                    return "La respuesta de recuperación de contraseña proporcionada no es válida. Por favor, compruebe el valor y vuelva a intentarlo.";

                case MembershipCreateStatus.InvalidQuestion:
                    return "La pregunta de recuperación de la contraseña proporcionada no es válida. Por favor, compruebe el valor y vuelva a intentarlo.";

                case MembershipCreateStatus.InvalidUserName:
                    return "El nombre de usuario proporcionado no es válido. Por favor, compruebe el valor y vuelva a intentarlo.";

                case MembershipCreateStatus.ProviderError:
                    return "El proveedor de autenticación retornó un error. Por favor, verifique su entrada y vuelva a intentarlo. Si el problema persiste, póngase en contacto con el administrador del sistema.";

                case MembershipCreateStatus.UserRejected:
                    return "La solicitud de creación de usuario ha sido cancelada. Por favor, verifique su entrada y vuelva a intentarlo. Si el problema persiste, póngase en contacto con el administrador del sistema.";

                default:
                    return "Ocurrió un error desconocido. Por favor, verifique su entrada y vuelva a intentarlo. Si el problema persiste, póngase en contacto con el administrador del sistema.";
            }
        }
        #endregion
    }
}
